/**
 * 订单模块的Vuex状态管理
 * @module store/modules/order
 * @author 团队名称
 * @description 订单模块的状态管理，包含订单列表、详情、物流信息等
 */
import * as orderApi from '@/api/order';
import { 
  orderList, 
  ORDER_STATUS, 
  mockGetOrderList, 
  mockGetOrderDetail, 
  mockGetLogistics, 
  mockPayOrder,
  mockConfirmReceipt
} from '@/mock/order';
import { USE_MOCK } from '@/api/config';

/**
 * 状态定义
 * @typedef {Object} OrderState
 * @property {Array} orderList - 订单列表
 * @property {Object|null} currentOrder - 当前选中的订单
 * @property {Array} logistics - 物流信息
 * @property {Boolean} loadingOrderList - 是否正在加载订单列表
 * @property {Boolean} loadingOrderDetail - 是否正在加载订单详情
 * @property {Boolean} loadingLogistics - 是否正在加载物流信息
 */
const state = {
  /** 订单列表 */
  orderList: [],
  /** 当前选中的订单 */
  currentOrder: null,
  /** 物流信息 */
  logistics: [],
  /** 是否正在加载订单列表 */
  loadingOrderList: false,
  /** 是否正在加载订单详情 */
  loadingOrderDetail: false,
  /** 是否正在加载物流信息 */
  loadingLogistics: false
};

/**
 * 变更方法
 * @type {Object}
 */
const mutations = {
  /**
   * 设置订单列表
   * @param {OrderState} state - 状态
   * @param {Array} orders - 订单列表
   */
  SET_ORDER_LIST(state, orders) {
    state.orderList = orders;
  },
  
  /**
   * 设置当前订单
   * @param {OrderState} state - 状态
   * @param {Object} order - 订单对象
   */
  SET_CURRENT_ORDER(state, order) {
    state.currentOrder = order;
  },
  
  /**
   * 设置物流信息
   * @param {OrderState} state - 状态
   * @param {Array} logistics - 物流信息数组
   */
  SET_LOGISTICS(state, logistics) {
    state.logistics = logistics;
  },
  
  /**
   * 设置订单列表加载状态
   * @param {OrderState} state - 状态
   * @param {Boolean} loading - 是否加载中
   */
  SET_LOADING_ORDER_LIST(state, loading) {
    state.loadingOrderList = loading;
  },
  
  /**
   * 设置订单详情加载状态
   * @param {OrderState} state - 状态
   * @param {Boolean} loading - 是否加载中
   */
  SET_LOADING_ORDER_DETAIL(state, loading) {
    state.loadingOrderDetail = loading;
  },
  
  /**
   * 设置物流信息加载状态
   * @param {OrderState} state - 状态
   * @param {Boolean} loading - 是否加载中
   */
  SET_LOADING_LOGISTICS(state, loading) {
    state.loadingLogistics = loading;
  },
  
  /**
   * 更新订单状态
   * @param {OrderState} state - 状态
   * @param {Object} payload - 参数
   * @param {Number|String} payload.orderId - 订单ID
   * @param {String} payload.status - 订单状态
   */
  UPDATE_ORDER_STATUS(state, { orderId, status }) {
    const order = state.orderList.find(o => o.id === Number(orderId));
    if (order) {
      order.status = status;
    }
    if (state.currentOrder && state.currentOrder.id === Number(orderId)) {
      state.currentOrder.status = status;
    }
  }
};

/**
 * actions 操作方法
 * @type {Object}
 */
const actions = {
  /**
   * 获取订单列表
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Object} params - 查询参数
   * @returns {Promise<void>}
   */
  async fetchOrderList({ commit }, params) {
    commit('SET_LOADING_ORDER_LIST', true);
    try {
      let res;
      if (USE_MOCK) {
        // 使用mock数据
        res = await mockGetOrderList(params);
      } else {
        // 实际环境中调用API
        res = await orderApi.getOrderList(params);
      }
      
      if (res.code === 200 || res.code === 0) {
        commit('SET_ORDER_LIST', res.data.list || res.data);
      } else {
        uni.showToast({
          title: res.message || '获取订单列表失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('获取订单列表失败', error);
      uni.showToast({
        title: '获取订单列表失败',
        icon: 'none'
      });
    } finally {
      commit('SET_LOADING_ORDER_LIST', false);
    }
  },
  
  /**
   * 获取订单详情
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Number|String} orderId - 订单ID
   * @returns {Promise<void>}
   */
  async fetchOrderDetail({ commit }, orderId) {
    commit('SET_LOADING_ORDER_DETAIL', true);
    try {
      let res;
      if (USE_MOCK) {
        // 使用mock数据
        res = await mockGetOrderDetail(orderId);
      } else {
        // 实际环境中调用API
        res = await orderApi.getOrderDetail(orderId);
      }
      
      if (res.code === 200 || res.code === 0) {
        commit('SET_CURRENT_ORDER', res.data);
      } else {
        uni.showToast({
          title: res.message || '获取订单详情失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('获取订单详情失败', error);
      uni.showToast({
        title: '获取订单详情失败',
        icon: 'none'
      });
    } finally {
      commit('SET_LOADING_ORDER_DETAIL', false);
    }
  },
  
  /**
   * 获取物流信息
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Number|String} orderId - 订单ID
   * @returns {Promise<void>}
   */
  async fetchLogistics({ commit }, orderId) {
    commit('SET_LOADING_LOGISTICS', true);
    try {
      let res;
      if (USE_MOCK) {
        // 使用mock数据
        res = await mockGetLogistics(orderId);
      } else {
        // 实际环境中调用API
        res = await orderApi.getLogistics(orderId);
      }
      
      if (res.code === 200 || res.code === 0) {
        commit('SET_LOGISTICS', res.data);
      } else {
        uni.showToast({
          title: res.message || '获取物流信息失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('获取物流信息失败', error);
      uni.showToast({
        title: '获取物流信息失败',
        icon: 'none'
      });
    } finally {
      commit('SET_LOADING_LOGISTICS', false);
    }
  },
  
  /**
   * 支付订单
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Number|String} orderId - 订单ID
   * @returns {Promise<Boolean>} 支付结果
   */
  async payOrder({ commit }, orderId) {
    try {
      let res;
      if (USE_MOCK) {
        // 使用mock数据
        res = await mockPayOrder(orderId);
      } else {
        // 实际环境中调用API
        res = await orderApi.payOrder(orderId);
      }
      
      if (res.code === 200 || res.code === 0) {
        commit('UPDATE_ORDER_STATUS', { orderId, status: ORDER_STATUS.UNDELIVERED });
        uni.showToast({
          title: '支付成功',
          icon: 'success'
        });
        return true;
      } else {
        uni.showToast({
          title: res.message || '支付失败',
          icon: 'none'
        });
        return false;
      }
    } catch (error) {
      console.error('支付失败', error);
      uni.showToast({
        title: '支付失败',
        icon: 'none'
      });
      return false;
    }
  },
  
  /**
   * 确认收货
   * @param {Object} context - Vuex上下文
   * @param {Function} context.commit - commit方法
   * @param {Number|String} orderId - 订单ID
   * @returns {Promise<Boolean>} 确认结果
   */
  async confirmReceipt({ commit }, orderId) {
    try {
      let res;
      if (USE_MOCK) {
        // 使用mock数据
        res = await mockConfirmReceipt(orderId);
      } else {
        // 实际环境中调用API
        res = await orderApi.confirmReceipt(orderId);
      }
      
      if (res.code === 200 || res.code === 0) {
        commit('UPDATE_ORDER_STATUS', { orderId, status: ORDER_STATUS.COMPLETED });
        uni.showToast({
          title: '确认收货成功',
          icon: 'success'
        });
        return true;
      } else {
        uni.showToast({
          title: res.message || '确认收货失败',
          icon: 'none'
        });
        return false;
      }
    } catch (error) {
      console.error('确认收货失败', error);
      uni.showToast({
        title: '确认收货失败',
        icon: 'none'
      });
      return false;
    }
  }
};

/**
 * getters计算属性
 * @type {Object}
 */
const getters = {
  /**
   * 按状态分类的订单列表
   * @param {OrderState} state - 状态
   * @returns {Function} 返回一个函数，接收状态参数返回过滤后的订单列表
   */
  ordersByStatus: (state) => (status) => {
    if (status === 'all') {
      return state.orderList;
    }
    return state.orderList.filter(order => order.status === status);
  },
  
  /**
   * 获取订单状态文本
   * @returns {Function} 返回一个函数，将状态码转换为可读文本
   */
  getStatusText: () => (status) => {
    const statusMap = {
      [ORDER_STATUS.UNPAID]: '待付款',
      [ORDER_STATUS.UNDELIVERED]: '待发货',
      [ORDER_STATUS.DELIVERED]: '待收货',
      [ORDER_STATUS.COMPLETED]: '已完成',
      [ORDER_STATUS.CANCELLED]: '已取消'
    };
    return statusMap[status] || '未知状态';
  },
  
  /**
   * 获取订单数量
   * @param {OrderState} state - 状态
   * @returns {Object} 各状态的订单数量
   */
  orderCounts: (state) => {
    const counts = {
      all: state.orderList.length,
      [ORDER_STATUS.UNPAID]: 0,
      [ORDER_STATUS.UNDELIVERED]: 0,
      [ORDER_STATUS.DELIVERED]: 0,
      [ORDER_STATUS.COMPLETED]: 0,
      [ORDER_STATUS.CANCELLED]: 0
    };
    
    state.orderList.forEach(order => {
      if (counts[order.status] !== undefined) {
        counts[order.status]++;
      }
    });
    
    return counts;
  }
};

/**
 * 订单模块导出
 * @type {Object}
 */
export default {
  namespaced: true,
  state,
  mutations,
  actions,
  getters
};
